home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / rex.lha / rex / test / in next >
Encoding:
Text File  |  1992-08-18  |  14.9 KB  |  685 lines
  1. (* $Id$ *)
  2.  
  3. (* $Log$
  4.  *)
  5.  
  6. MODULE ScanDrv;
  7.  
  8. FROM Scanner IMPORT BeginScanner, GetToken, EofToken, CloseScanner;
  9.  
  10. BEGIN
  11.    BeginScanner;
  12.    WHILE GetToken () # EofToken DO END;
  13.    CloseScanner;
  14. END ScanDrv.
  15. (* $Id$ *)
  16.  
  17. (* $Log$
  18.  *)
  19.  
  20. DEFINITION MODULE Scanner;
  21.  
  22. TYPE tAttribute    = INTEGER;
  23. PROCEDURE ErrorAttribute (Token: CARDINAL; VAR Attribute: tAttribute);
  24.  
  25. CONST
  26.    EofToken     = 0;
  27.  
  28. VAR
  29.    Line        ,
  30.    Column    : CARDINAL;
  31.    Attribute    : tAttribute;
  32.    ScanTabName    : ARRAY [0 .. 127] OF CHAR;
  33.  
  34. PROCEDURE BeginScanner;
  35. PROCEDURE GetToken    (): INTEGER;
  36. PROCEDURE CloseScanner;
  37.  
  38. END Scanner.
  39. (* $Id$ *)
  40.  
  41. (* $Log$
  42.  *)
  43.  
  44. IMPLEMENTATION MODULE Scanner;
  45.  
  46. IMPORT SYSTEM, Checks, SystemIO, IO, Source, Strings;
  47.  
  48.    VAR level        : CARDINAL;
  49.  
  50.    PROCEDURE ErrorAttribute (Token: CARDINAL; VAR Attribute: tAttribute);
  51.       BEGIN
  52.       END ErrorAttribute;
  53.  
  54.  
  55. CONST
  56.    yyDNoState        = 0;
  57.    yyTokenLngMax    = 256;
  58.    yyChBufferSize    = 2048;
  59. yyFirstCh    = 0C;
  60. yyLastCh    = 200C;
  61. yyEolCh    = 12C;
  62. yyEobCh    = 200C;
  63. yyDStateCount    = 218;
  64. yyTableSize    = 833;
  65. yyEobState    = 5;
  66. yyDefaultState    = 218;
  67. STD    = 1;
  68. comment    = 3;
  69.  
  70. TYPE
  71.    yyTableElmt        = SHORTCARD;
  72.    yyStateRange        = yyTableElmt [0 .. yyDStateCount];
  73.    yyTableRange        = yyTableElmt [0 .. yyTableSize];
  74.    yyCombType        = RECORD
  75.                  Check    ,
  76.                  Next    : yyStateRange    ;
  77.               END;
  78.    yyCombTypePtr    = POINTER TO yyCombType;
  79.    yyStStackRange    = SHORTCARD [0 .. yyTokenLngMax];
  80.    yyChBufferRange    = SHORTCARD [0 .. yyTokenLngMax + yyChBufferSize + 2];
  81.    yyChRange        = [yyFirstCh .. yyLastCh];
  82.  
  83. VAR
  84.    yyTableFile        : SystemIO.tFile;
  85.    yyElmtSize        : yyTableElmt;
  86.    yyBasePtr        : ARRAY yyStateRange    OF LONGCARD    ;
  87.    yyDefault        : ARRAY yyStateRange    OF yyStateRange    ;
  88.    yyComb        : ARRAY yyTableRange    OF yyCombType    ;
  89.    yyTokenLength    : CARDINAL;
  90.    yyLineCount        : CARDINAL;
  91.    yyStateStack        : ARRAY yyStStackRange    OF yyStateRange    ;
  92.    yyStartState        : yyStateRange;
  93.    yyPreviousStart    : yyStateRange;
  94.    yyChBuffer        : ARRAY yyChBufferRange    OF CHAR        ;
  95.    yyChBufferIndex    : yyChBufferRange;
  96.    yyBytesRead        : INTEGER;
  97.    yyToLower        : ARRAY yyChRange    OF yyChRange    ;
  98.    yyToUpper        : ARRAY yyChRange    OF yyChRange    ;
  99.    yyCh            : CHAR;
  100.  
  101. PROCEDURE GetToken (): INTEGER;
  102.    VAR
  103.       yyState        : yyStateRange;
  104.       yyTablePtr    : yyCombTypePtr;
  105.       yyRestartFlag    : BOOLEAN;
  106.       yyi        : SHORTINT;
  107. BEGIN
  108.    LOOP
  109.       Line        := yyLineCount;    (* initialize *)
  110.       INC (Column, yyTokenLength);
  111.       yyState        := yyStartState;
  112.       yyTokenLength     := 0;
  113.  
  114.       (* ASSERT yyChBuffer [yyChBufferIndex] = first character *)
  115.  
  116.       LOOP        (* eventually restart after sentinel *)
  117.      LOOP        (* execute as many state transitions as possible *)
  118.                         (* determine next state *)
  119.         yyTablePtr := yyCombTypePtr (yyBasePtr [yyState] +
  120.            ORD (yyChBuffer [yyChBufferIndex]) * SYSTEM.TSIZE (yyCombType));
  121.         IF yyTablePtr^.Check # yyState THEN
  122.            yyState := yyDefault [yyState];
  123.            IF yyState = yyDNoState THEN EXIT; END;
  124.         ELSE
  125.            yyState := yyTablePtr^.Next;
  126.            INC (yyTokenLength);
  127.            yyStateStack [yyTokenLength] := yyState;    (* push state *)
  128.            INC (yyChBufferIndex);    (* get next character *)
  129.         END;
  130.      END;
  131.  
  132.      LOOP                (* search for last final state *)
  133.         CASE yyStateStack [yyTokenLength] OF
  134. |216:
  135. INC (level); yyStart (comment);
  136. yyRestartFlag := FALSE; EXIT;
  137. |215:
  138. DEC (level); IF level = 0 THEN yyStart (STD); END;
  139. yyRestartFlag := FALSE; EXIT;
  140. |6,17,31,214,217:
  141.  
  142. yyRestartFlag := FALSE; EXIT;
  143. |8,20:
  144. RETURN 1;
  145. yyRestartFlag := FALSE; EXIT;
  146. |13:
  147. DEC (yyChBufferIndex, 2);
  148. DEC (yyTokenLength, 2);
  149. RETURN 1;
  150. yyRestartFlag := FALSE; EXIT;
  151. |14:
  152. RETURN 2;
  153. yyRestartFlag := FALSE; EXIT;
  154. |15:
  155. RETURN 3;
  156. yyRestartFlag := FALSE; EXIT;
  157. |12:
  158. RETURN 4;
  159. yyRestartFlag := FALSE; EXIT;
  160. |10,21,22:
  161. RETURN 5;
  162. yyRestartFlag := FALSE; EXIT;
  163. |16:
  164. RETURN 6;
  165. yyRestartFlag := FALSE; EXIT;
  166. |213:
  167. RETURN 7;
  168. yyRestartFlag := FALSE; EXIT;
  169. |212:
  170. RETURN 8;
  171. yyRestartFlag := FALSE; EXIT;
  172. |211:
  173. RETURN 9;
  174. yyRestartFlag := FALSE; EXIT;
  175. |210:
  176. RETURN 10;
  177. yyRestartFlag := FALSE; EXIT;
  178. |209:
  179. RETURN 11;
  180. yyRestartFlag := FALSE; EXIT;
  181. |208:
  182. RETURN 12;
  183. yyRestartFlag := FALSE; EXIT;
  184. |207:
  185. RETURN 13;
  186. yyRestartFlag := FALSE; EXIT;
  187. |206:
  188. RETURN 14;
  189. yyRestartFlag := FALSE; EXIT;
  190. |204:
  191. RETURN 15;
  192. yyRestartFlag := FALSE; EXIT;
  193. |205:
  194. RETURN 16;
  195. yyRestartFlag := FALSE; EXIT;
  196. |203:
  197. RETURN 17;
  198. yyRestartFlag := FALSE; EXIT;
  199. |201:
  200. RETURN 18;
  201. yyRestartFlag := FALSE; EXIT;
  202. |202:
  203. RETURN 19;
  204. yyRestartFlag := FALSE; EXIT;
  205. |200:
  206. RETURN 20;
  207. yyRestartFlag := FALSE; EXIT;
  208. |197:
  209. RETURN 21;
  210. yyRestartFlag := FALSE; EXIT;
  211. |199:
  212. RETURN 22;
  213. yyRestartFlag := FALSE; EXIT;
  214. |198:
  215. RETURN 23;
  216. yyRestartFlag := FALSE; EXIT;
  217. |196:
  218. RETURN 24;
  219. yyRestartFlag := FALSE; EXIT;
  220. |194:
  221. RETURN 25;
  222. yyRestartFlag := FALSE; EXIT;
  223. |195:
  224. RETURN 26;
  225. yyRestartFlag := FALSE; EXIT;
  226. |193:
  227. RETURN 27;
  228. yyRestartFlag := FALSE; EXIT;
  229. |192:
  230. RETURN 28;
  231. yyRestartFlag := FALSE; EXIT;
  232. |191:
  233. RETURN 29;
  234. yyRestartFlag := FALSE; EXIT;
  235. |190:
  236. RETURN 30;
  237. yyRestartFlag := FALSE; EXIT;
  238. |189:
  239. RETURN 31;
  240. yyRestartFlag := FALSE; EXIT;
  241. |188:
  242. RETURN 32;
  243. yyRestartFlag := FALSE; EXIT;
  244. |187:
  245. RETURN 33;
  246. yyRestartFlag := FALSE; EXIT;
  247. |186:
  248. RETURN 34;
  249. yyRestartFlag := FALSE; EXIT;
  250. |184:
  251. RETURN 35;
  252. yyRestartFlag := FALSE; EXIT;
  253. |179:
  254. RETURN 36;
  255. yyRestartFlag := FALSE; EXIT;
  256. |175:
  257. RETURN 37;
  258. yyRestartFlag := FALSE; EXIT;
  259. |173:
  260. RETURN 38;
  261. yyRestartFlag := FALSE; EXIT;
  262. |170:
  263. RETURN 39;
  264. yyRestartFlag := FALSE; EXIT;
  265. |165:
  266. RETURN 40;
  267. yyRestartFlag := FALSE; EXIT;
  268. |156:
  269. RETURN 41;
  270. yyRestartFlag := FALSE; EXIT;
  271. |154:
  272. RETURN 42;
  273. yyRestartFlag := FALSE; EXIT;
  274. |152:
  275. RETURN 43;
  276. yyRestartFlag := FALSE; EXIT;
  277. |151:
  278. RETURN 44;
  279. yyRestartFlag := FALSE; EXIT;
  280. |147:
  281. RETURN 45;
  282. yyRestartFlag := FALSE; EXIT;
  283. |145:
  284. RETURN 46;
  285. yyRestartFlag := FALSE; EXIT;
  286. |143:
  287. RETURN 47;
  288. yyRestartFlag := FALSE; EXIT;
  289. |137:
  290. RETURN 48;
  291. yyRestartFlag := FALSE; EXIT;
  292. |135:
  293. RETURN 49;
  294. yyRestartFlag := FALSE; EXIT;
  295. |131:
  296. RETURN 50;
  297. yyRestartFlag := FALSE; EXIT;
  298. |130:
  299. RETURN 51;
  300. yyRestartFlag := FALSE; EXIT;
  301. |119:
  302. RETURN 52;
  303. yyRestartFlag := FALSE; EXIT;
  304. |114:
  305. RETURN 53;
  306. yyRestartFlag := FALSE; EXIT;
  307. |112:
  308. RETURN 54;
  309. yyRestartFlag := FALSE; EXIT;
  310. |105:
  311. RETURN 55;
  312. yyRestartFlag := FALSE; EXIT;
  313. |108:
  314. RETURN 56;
  315. yyRestartFlag := FALSE; EXIT;
  316. |102:
  317. RETURN 57;
  318. yyRestartFlag := FALSE; EXIT;
  319. |99:
  320. RETURN 58;
  321. yyRestartFlag := FALSE; EXIT;
  322. |98:
  323. RETURN 59;
  324. yyRestartFlag := FALSE; EXIT;
  325. |96:
  326. RETURN 60;
  327. yyRestartFlag := FALSE; EXIT;
  328. |90:
  329. RETURN 61;
  330. yyRestartFlag := FALSE; EXIT;
  331. |81:
  332. RETURN 62;
  333. yyRestartFlag := FALSE; EXIT;
  334. |72:
  335. RETURN 63;
  336. yyRestartFlag := FALSE; EXIT;
  337. |68:
  338. RETURN 64;
  339. yyRestartFlag := FALSE; EXIT;
  340. |64:
  341. RETURN 65;
  342. yyRestartFlag := FALSE; EXIT;
  343. |58:
  344. RETURN 66;
  345. yyRestartFlag := FALSE; EXIT;
  346. |55:
  347. RETURN 67;
  348. yyRestartFlag := FALSE; EXIT;
  349. |52:
  350. RETURN 68;
  351. yyRestartFlag := FALSE; EXIT;
  352. |51:
  353. RETURN 69;
  354. yyRestartFlag := FALSE; EXIT;
  355. |47:
  356. RETURN 70;
  357. yyRestartFlag := FALSE; EXIT;
  358. |42:
  359. RETURN 71;
  360. yyRestartFlag := FALSE; EXIT;
  361. |39:
  362. RETURN 72;
  363. yyRestartFlag := FALSE; EXIT;
  364. |35:
  365. RETURN 73;
  366. yyRestartFlag := FALSE; EXIT;
  367. |9,32,33,34,36,37,38,40,41,43,44,45,46,48,49,50,53,54,56,57,59,60,61,62,63,65,66,67,69,70,71,73,74,75,76,77,78,79,80,82,83,84,85,86,87,88,89,91,92,93,94,95,97,100,101,103,104,106,107,109,110,111,113,115,116,117,118,120,121,122,123,124,125,126,127,128,129,132,133,134,136,138,139,140,141,142,144,146,148,149,150,153,155,157,158,159,160,161,162,163,164,166,167,168,169,171,172,174,176,177,178,180,181,182,183,185:
  368. RETURN 74;
  369. yyRestartFlag := FALSE; EXIT;
  370. |7,18,19:
  371. IO.WriteS (IO.StdOutput, "illegal character: ");
  372.                yyEcho;
  373.                IO.WriteNl (IO.StdOutput);
  374. yyRestartFlag := FALSE; EXIT;
  375. |30:
  376. (* BlankAction *)
  377. WHILE yyChBuffer [yyChBufferIndex] = ' ' DO
  378.    INC (yyChBufferIndex);
  379.    INC (yyTokenLength);
  380. END;
  381. INC (Column, yyTokenLength);
  382. yyState     := yyStartState;
  383. yyTokenLength := 0;
  384. yyRestartFlag := TRUE; EXIT;
  385. yyRestartFlag := FALSE; EXIT;
  386. |29:
  387. (* TabAction *)
  388. INC (Column, 7 - (Column - 1) MOD 8);
  389. yyRestartFlag := FALSE; EXIT;
  390. |28:
  391. (* EolAction *)
  392. INC (yyLineCount);
  393. Column := 0;
  394. yyRestartFlag := FALSE; EXIT;
  395. |0,1,2,3,4,11,23,24,25,26,27:
  396.         (* non final states *)
  397.           DEC (yyChBufferIndex);    (* return character *)
  398.           DEC (yyTokenLength)        (* pop state *)
  399.  
  400.         |  yyDefaultState    : 
  401.           IO.WriteC (IO.StdOutput, yyChBuffer [yyChBufferIndex]);
  402.           INC (yyChBufferIndex);
  403.               yyRestartFlag := FALSE; EXIT;
  404.  
  405.         |  yyEobState    :
  406.  
  407.           IF yyBytesRead = 0 THEN    (* end of file reached *)
  408.              IF Source.CloseSource () THEN
  409.             yyTokenLength := 0;
  410.             RETURN EofToken;
  411.              ELSE
  412.             yyGetChBuffer;
  413.             yyRestartFlag := FALSE;
  414.             EXIT;
  415.              END;
  416.           ELSE                (* read buffer *)
  417.              DEC (yyChBufferIndex);
  418.              DEC (yyTokenLength);
  419.              IF yyTokenLength = 0 THEN
  420.             yyState := yyStartState;
  421.              ELSE
  422.             yyState := yyStateStack [yyTokenLength];
  423.              END;
  424.  
  425.              (* copy initial part of token in front of input buffer *)
  426.  
  427.              FOR yyi := - INTEGER (yyTokenLength) TO -1 DO
  428.             yyChBuffer [yyTokenLngMax + 1 + yyi] :=
  429.             yyChBuffer [SHORTINT (yyChBufferIndex) + yyi];
  430.              END;
  431.              yyGetChBuffer;
  432.              yyRestartFlag := TRUE;
  433.              EXIT;
  434.           END;
  435.  
  436.         ELSE
  437.            yyAnalyzeError;
  438.         END;
  439.      END;
  440.      IF yyRestartFlag THEN ELSE EXIT; END;
  441.       END;
  442.    END;
  443.    END GetToken;
  444.  
  445. PROCEDURE yyGetChBuffer;
  446.    BEGIN
  447.       yyChBufferIndex := yyTokenLngMax + 1;
  448.       yyBytesRead := Source.GetLine (SYSTEM.ADR (yyChBuffer [yyChBufferIndex]), yyChBufferSize);
  449.       IF yyBytesRead < 0 THEN
  450.      yyBytesRead := 0;
  451.       END;
  452.       yyChBuffer [yyBytesRead + yyTokenLngMax + 1] := yyEobCh;
  453.       yyChBuffer [yyBytesRead + yyTokenLngMax + 2] := 0C;
  454.    END yyGetChBuffer;
  455.  
  456. PROCEDURE GetWord (VAR Word: Strings.tString);
  457.    VAR
  458.       i        : CARDINAL;
  459.       WordStart    : yyChBufferRange;
  460.    BEGIN
  461.       WordStart := yyChBufferIndex - yyTokenLength - 1;
  462.       FOR i := 1 TO yyTokenLength DO
  463.      Word.Chars [i] := yyChBuffer [WordStart + i];
  464.       END;
  465.       Word.Length := yyTokenLength;
  466.    END GetWord;
  467.  
  468. PROCEDURE GetLower (VAR Word: Strings.tString);
  469.    VAR
  470.       i        : CARDINAL;
  471.       WordStart    : yyChBufferRange;
  472.    BEGIN
  473.       WordStart := yyChBufferIndex - yyTokenLength - 1;
  474.       FOR i := 1 TO yyTokenLength DO
  475.      Word.Chars [i] := yyToLower [yyChBuffer [WordStart + i]];
  476.       END;
  477.       Word.Length := yyTokenLength;
  478.    END GetLower;
  479.  
  480. PROCEDURE GetUpper (VAR Word: Strings.tString);
  481.    VAR
  482.       i        : CARDINAL;
  483.       WordStart    : yyChBufferRange;
  484.    BEGIN
  485.       WordStart := yyChBufferIndex - yyTokenLength - 1;
  486.       FOR i := 1 TO yyTokenLength DO
  487.      Word.Chars [i] := yyToUpper [yyChBuffer [WordStart + i]];
  488.       END;
  489.       Word.Length := yyTokenLength;
  490.    END GetUpper;
  491.  
  492. PROCEDURE yyStart (State: yyStateRange);
  493.    BEGIN
  494.       yyPreviousStart    := yyStartState;
  495.       yyStartState    := State;
  496.    END yyStart;
  497.  
  498. PROCEDURE yyPrevious;
  499.    BEGIN
  500.       yyStartState    := yyPreviousStart;
  501.    END yyPrevious;
  502.  
  503. PROCEDURE yyEcho;
  504.    VAR Word    : Strings.tString;
  505.    BEGIN
  506.       GetWord (Word);
  507.       Strings.WriteS (IO.StdOutput, Word);
  508.    END yyEcho;
  509.  
  510. PROCEDURE yyLess (n: CARDINAL);
  511.    BEGIN
  512.       DEC (yyChBufferIndex, yyTokenLength - n);
  513.       yyTokenLength := n;
  514.    END yyLess;
  515.  
  516. PROCEDURE yyTab;
  517.    BEGIN
  518.       INC (Column, 7 - (Column - 1) MOD 8);
  519.    END yyTab;
  520.  
  521. PROCEDURE yyTab2 (a, b: CARDINAL);
  522.    BEGIN
  523.       INC (Column, a);
  524.       INC (Column, 7 - (Column - 1) MOD 8);
  525.       INC (Column, b);
  526.    END yyTab2;
  527.  
  528. PROCEDURE yyEol (pColumn: CARDINAL);
  529.    BEGIN
  530.       INC (yyLineCount);
  531.       Column := pColumn;
  532.    END yyEol;
  533.  
  534. PROCEDURE BeginScanner;
  535.    BEGIN
  536.       IF yyStartState = 0 THEN
  537.      yyGetTables;
  538.       END;
  539.       yyStartState    := STD;
  540.       yyTokenLength    := 0;
  541.       yyLineCount    := 1;
  542.       Column        := 1;
  543.       yyStateStack [0]    := yyDefaultState;
  544.       yyChBuffer [yyTokenLngMax] := yyEolCh;
  545.       yyGetChBuffer;
  546.  level := 0; 
  547.    END BeginScanner;
  548.  
  549. PROCEDURE CloseScanner;
  550.    BEGIN
  551.    END CloseScanner;
  552.  
  553. PROCEDURE yyGetTables;
  554.    VAR
  555.       i        : yyStateRange;
  556.       yyBase    : ARRAY yyStateRange    OF yyTableRange    ;
  557.    BEGIN
  558.       yyTableFile := SystemIO.OpenInput (ScanTabName);
  559.       Checks.ErrorCheck ("yyGetTables.OpenInput", yyTableFile);
  560.       IF (yyGetTable (SYSTEM.ADR (yyBase   )) DIV yyElmtSize - 1
  561.         # yyDStateCount) OR
  562.          (yyGetTable (SYSTEM.ADR (yyDefault)) DIV yyElmtSize - 1
  563.         # yyDStateCount) OR
  564.          (yyGetTable (SYSTEM.ADR (yyComb   )) DIV SYSTEM.TSIZE (yyCombType) - 1
  565.         # yyTableSize) THEN
  566.      IO.WriteS (IO.StdError, "Scanner: table mismatch");
  567.      IO.WriteNl (IO.StdError);
  568.      IO.CloseIO;
  569.      HALT;
  570.       END;
  571.       SystemIO.Close (yyTableFile);
  572.  
  573.       FOR i := 0 TO yyDStateCount DO
  574.      yyBasePtr [i] := LONGCARD (SYSTEM.ADR (yyComb [yyBase [i]]));
  575.       END;
  576.    END yyGetTables;
  577.  
  578. PROCEDURE yyGetTable (Address: SYSTEM.ADDRESS): CARDINAL;
  579.    VAR
  580.       N        : INTEGER;
  581.       Length    : yyTableElmt;
  582.    BEGIN
  583.       N := SystemIO.Read (yyTableFile, SYSTEM.ADR (Length), yyElmtSize);
  584.       Checks.ErrorCheck ("yyGetTable.Read1", N);
  585.       N := SystemIO.Read (yyTableFile, Address, Length);
  586.       Checks.ErrorCheck ("yyGetTable.Read2", N);
  587.       RETURN Length;
  588.    END yyGetTable;
  589.  
  590. PROCEDURE yyAnalyzeError;
  591.    BEGIN
  592.       IF yyStartState = 0 THEN
  593.      IO.WriteS (IO.StdError, "Scanner: initialization missing");
  594.       ELSIF yyTokenLength >= yyTokenLngMax THEN
  595.      IO.WriteS (IO.StdError, "Scanner: token too long");
  596.       ELSE
  597.      IO.WriteS (IO.StdError, "Scanner: internal error");
  598.       END;
  599.       IO.WriteNl (IO.StdError);
  600.       IO.CloseIO;
  601.       HALT;
  602.    END yyAnalyzeError;
  603.  
  604. BEGIN
  605.    yyElmtSize    := SYSTEM.TSIZE (yyTableElmt);
  606.    yyStartState    := 0;
  607.    ScanTabName    := "ScanTab";
  608.    
  609.    FOR yyCh := yyFirstCh TO yyLastCh DO
  610.       yyToLower [yyCh] := yyCh;
  611.       yyToUpper [yyCh] := yyCh;
  612.    END;
  613.    FOR yyCh := 'A' TO 'Z' DO
  614.       yyToLower [yyCh] := CHR (ORD (yyCh) - ORD ('A') + ORD ('a'));
  615.    END;
  616.    FOR yyCh := 'a' TO 'z' DO
  617.       yyToUpper [yyCh] := CHR (ORD (yyCh) - ORD ('a') + ORD ('A'));
  618.    END;
  619. END Scanner.
  620. (* $Id$ *)
  621.  
  622. (* $Log$
  623.  *)
  624.  
  625. DEFINITION MODULE Source;
  626.  
  627. FROM SYSTEM    IMPORT ADDRESS;
  628.  
  629. PROCEDURE BeginSource ();
  630.  
  631.    (*
  632.       BeginSource is called before scanning starts.
  633.       It can be used to open files etc.
  634.    *)
  635.  
  636. PROCEDURE GetLine (Buffer: ADDRESS; Size: CARDINAL): INTEGER;
  637.  
  638.    (*
  639.       GetLine is called to fill a buffer starting at address 'Buffer'
  640.       with a block of maximal 'Size' characters. Lines are terminated
  641.       by newline characters (ASCII = 0A). GetLine returns the number
  642.       of characters transferred. Reasonable block sizes are between 128
  643.       and 2048 or the length of a line. Smaller block sizes -
  644.       especially block size 1 - will drastically slow down the scanner.
  645.    *)
  646.  
  647. PROCEDURE CloseSource (): BOOLEAN;
  648.  
  649.    (*
  650.       CloseSource is called at end of file resp. input.
  651.       It can be used to close files or to redirect input.
  652.  
  653.       if CloseSource returns true    : scanner stops     
  654.       if CloseSource returns false    : scanner continues 
  655.    *)
  656.  
  657. END Source.
  658. (* $Id$ *)
  659.  
  660. (* $Log$
  661.  *)
  662.  
  663. IMPLEMENTATION MODULE Source;
  664.  
  665. FROM SystemIO    IMPORT StdInput, Read;
  666. FROM SYSTEM    IMPORT ADDRESS;
  667.  
  668. PROCEDURE BeginSource ();
  669.    BEGIN
  670.    END BeginSource;
  671.  
  672. PROCEDURE GetLine (Buffer: ADDRESS; Size: CARDINAL): INTEGER;
  673.    BEGIN
  674.       RETURN Read (StdInput, Buffer, Size);
  675.    END GetLine;
  676.  
  677. PROCEDURE CloseSource (): BOOLEAN;
  678.    BEGIN
  679.       RETURN TRUE;
  680.    END CloseSource;
  681.  
  682. BEGIN
  683.    BeginSource;
  684. END Source.
  685.